package 反射;

//在查看反射相关的Class、Field 、Constructor 等类时，看到他们都有这样一个方法：getModifiers()：返回此类或接口以整数编码的 Java 语言修饰符。
//如需要知道返回的值所代表的意思，则需要用到 java.lang.reflect.Modifier 这个类，这个类提供了 static 方法和常量，可以对类和成员访问修饰符进行解码。
//
//既然是位于 java.lang.reflect 下，那说明一般是在动态加载过程中、使用java反射对某些类进行过滤时会用到，一般开发并不是很常用。但是对于写框架，个人还是觉
//得可以用到的。
//
//Modifier 修饰符工具类
//public class java.lang.reflect.Modifier extends Object
//
//JDK中的介绍：
//
//Modifier 类提供了 static 方法和常量，对类和成员访问修饰符进行解码。修饰符集被表示为整数，用不同的位位置 (bit position) 表示不同的修饰符。
//表示修饰符的常量值取自于 The JavaTM Virtual Machine Specification, Second edition 的表 4.1、4.4、4.5 和 4.7。
//
//访问修饰符列表
//public static final int PUBLIC  = 0x00000001;//0000 0000 0000 0001
//public static final int PRIVATE  = 0x00000002;//0000 0000 0000 0010
//public static final int PROTECTED  = 0x00000004;//0000 0000 0000 0100
//public static final int STATIC  = 0x00000008;//0000 0000 0000 1000
//public static final int FINAL  = 0x00000010;//0000 0000 0001 0000
//public static final int SYNCHRONIZED  = 0x00000020; 同步  //0000 0000 0010 0000
//public static final int VOLATILE  = 0x00000040; 用volatile修饰的变量，线程在每次使用变量的时候，都会读取变量修改后的最的值。//0000 0000 0100 0000
//public static final int TRANSIENT  = 0x00000080;     用transient关键字标记的成员变量不参与序列化过程。  //0000 0000 1000 0000
//public static final int NATIVE  = 0x00000100;  //0000 0001 0000 0000
//public static final int INTERFACE  = 0x00000200;//0000 0010 0000 0000
//public static final int ABSTRACT  = 0x00000400;//0000 0100 0000 0000
//public static final int STRICT  = 0x00000800; 即strictfp(strict float point 精确浮点)，此关键字可应用于类、接口或方法。//0000 1000 0000 0000
//
//解码方法
//以上所有的修饰符都有对应的、方法声明为【public static boolean is***(int mod)】的解码方法，且方法的实现也都是类似的，比如：
//
//public static boolean isPublic(int mod) {
//    return (mod & PUBLIC) != 0;  //mod=0000 0000 0000 0001(只要最低位为1)  PUBLIC=0000 0000 0000 0001
//}
//
//新增的方法
//1.7及1.8中新增了几个API，目的是对CLASS、INTERFACE、CONSTRUCTOR、METHOD、FIELD、PARAMETER等类型的对象可以使用的所有修饰符。
//
//private static final int CLASS_MODIFIERS =//0000 1100 0001 1111  
//    Modifier.PUBLIC         | Modifier.PROTECTED    | Modifier.PRIVATE |
//    Modifier.ABSTRACT       | Modifier.STATIC       | Modifier.FINAL   |
//    Modifier.STRICT;
//public static int classModifiers() {
//    return CLASS_MODIFIERS;
//}
// 
//private static final int INTERFACE_MODIFIERS =//0000 1100 0000 1111
//    Modifier.PUBLIC         | Modifier.PROTECTED    | Modifier.PRIVATE |
//    Modifier.ABSTRACT       | Modifier.STATIC       | Modifier.STRICT;
//public static int interfaceModifiers() {
//    return INTERFACE_MODIFIERS;
//}
// 
//private static final int CONSTRUCTOR_MODIFIERS =
//    Modifier.PUBLIC         | Modifier.PROTECTED    | Modifier.PRIVATE;
//public static int constructorModifiers() {
//    return CONSTRUCTOR_MODIFIERS;
//}
// 
//private static final int METHOD_MODIFIERS =
//    Modifier.PUBLIC         | Modifier.PROTECTED    | Modifier.PRIVATE |
//    Modifier.ABSTRACT       | Modifier.STATIC       | Modifier.FINAL   |
//    Modifier.SYNCHRONIZED   | Modifier.NATIVE       | Modifier.STRICT;
//public static int methodModifiers() {
//    return METHOD_MODIFIERS;
//}
// 
//private static final int FIELD_MODIFIERS =//0000 0000 1101 1111
//    Modifier.PUBLIC         | Modifier.PROTECTED    | Modifier.PRIVATE |
//    Modifier.STATIC         | Modifier.FINAL        | Modifier.TRANSIENT |
//    Modifier.VOLATILE;
//public static int fieldModifiers() {
//    return FIELD_MODIFIERS;
//}
// 
//private static final int PARAMETER_MODIFIERS =
//    Modifier.FINAL;
//public static int parameterModifiers() {
//    return PARAMETER_MODIFIERS;
//}
// 
//
//toString 方法的实现
//public static String toString(int mod) {
//    StringBuilder sb = new StringBuilder();
//    int len;
//
//    if ((mod & PUBLIC) != 0)        sb.append("public ");
//    if ((mod & PROTECTED) != 0)     sb.append("protected ");
//    if ((mod & PRIVATE) != 0)       sb.append("private ");
// 
//    /* Canonical典范、规范 order */
//    if ((mod & ABSTRACT) != 0)      sb.append("abstract ");
//    if ((mod & STATIC) != 0)        sb.append("static ");
//    if ((mod & FINAL) != 0)         sb.append("final ");
//    if ((mod & TRANSIENT) != 0)     sb.append("transient ");
//    if ((mod & VOLATILE) != 0)      sb.append("volatile ");
//    if ((mod & SYNCHRONIZED) != 0)  sb.append("synchronized ");
//    if ((mod & NATIVE) != 0)        sb.append("native ");
//    if ((mod & STRICT) != 0)        sb.append("strictfp ");
//    if ((mod & INTERFACE) != 0)     sb.append("interface ");
// 
//    /* trim trailing space */
//    if ((len = sb.length()) > 0)  return sb.toString().substring(0, len-1);
//    return "";
//}
// 
//
//示例1：解码mod演示
import java.lang.reflect.Modifier;
import java.util.Arrays;
public class Modifier类 {
	private static final transient int temp = 1;
 
	public static void main(String[] args) throws Exception {
		testModifier(Modifier类.class.getDeclaredField("temp").getModifiers());//154。private static final transient
		testModifier(Modifier类.class.getMethod("main", String[].class).getModifiers());//9。public static
	}
 
	public static void testModifier(int mod) {
		System.out.println("----------------------【mod=" + mod + "】----------------------");
		System.out.println("【toString】" + Modifier.toString(mod)+Integer.toString(mod,2));//1001 1010
		System.out.println("【isPublic】" + Modifier.isPublic(mod));
		System.out.println("【isPrivate】" + Modifier.isPrivate(mod));
		System.out.println("【isProtected】" + Modifier.isProtected(mod));
		System.out.println("【isStatic】" + Modifier.isStatic(mod));
		System.out.println("【isFinal】" + Modifier.isFinal(mod));
		System.out.println("【isSynchronized】" + Modifier.isSynchronized(mod));
		System.out.println("【isVolatile】" + Modifier.isVolatile(mod));
		System.out.println("【isTransient】" + Modifier.isTransient(mod));
		System.out.println("【isNative】" + Modifier.isNative(mod));
		System.out.println("【isInterface】" + Modifier.isInterface(mod));
		System.out.println("【isAbstract】" + Modifier.isAbstract(mod));
		System.out.println("【isStrict】" + Modifier.isStrict(mod));
	}
}
 
//
//示例2：不同类型元素可使用的修饰符
//System.out.println(Modifier.toString(Modifier.classModifiers()));//public protected private abstract static final strictfp
//System.out.println(Modifier.toString(Modifier.interfaceModifiers()));//public protected private abstract static strictfp
//System.out.println(Modifier.toString(Modifier.constructorModifiers()));//public protected private
//System.out.println(Modifier.toString(Modifier.methodModifiers()));//public protected private abstract static final synchronized native strictfp
//System.out.println(Modifier.toString(Modifier.fieldModifiers()));//public protected private static final transient volatile

